﻿#include <fstream>
#include <filesystem>
#include "evaluate.h"         // 包含 evaluate 类的声明
#include "context.h"          // 包含上下文相关的功能
#include "csv_recorder.h"     // 包含 CSV 记录功能
#include <interface.h>       // 包含接口相关定义
#include "inipp.h"           // 包含 INI 文件解析库
#include <params.hpp>        // 包含参数处理功能

// evaluate 类的构造函数
evaluate::evaluate() noexcept 
    : _market_simulator(nullptr), _trader_simulator(nullptr) // 初始化指针为 nullptr
{
}
	
// evaluate 类的析构函数
evaluate::~evaluate() noexcept
{
    // 清理资源
    if (_market_simulator)
    {
        destory_dummy_market(_market_simulator); // 销毁市场模拟器
    }
    if (_trader_simulator)
    {
        destory_dummy_trader(_trader_simulator); // 销毁交易模拟器
    }
}

// 从配置文件初始化 evaluate 对象
bool evaluate::init_from_file(const std::string& config_path) noexcept
{
    // 检查配置文件是否存在
    if (!std::filesystem::exists(config_path.c_str()))
    {
        LOG_ERROR("evaluate_driver init_from_file config_path not exit : %s", config_path.c_str());
        return false;
    }

    inipp::Ini<char> ini; // INI 文件解析对象
    std::ifstream is(config_path.c_str()); // 打开配置文件
    ini.parse(is); // 解析配置文件
    
    // 查找并处理 [include] 部分
    auto it = ini.sections.find("include");
    if (it == ini.sections.end())
    {
        LOG_ERROR("init_from_file cant find [include]", config_path.c_str());
        return false;
    }
    params include_patams(it->second); // 解析 include 部分的参数
    
    // 查找并处理 [dummy_market] 部分
    it = ini.sections.find("dummy_market");
    if (it == ini.sections.end())
    {
        LOG_ERROR("init_from_file cant find [dummy_market]", config_path.c_str());
        return false;
    }
    _market_simulator = create_dummy_market(it->second); // 创建市场模拟器
    if (_market_simulator == nullptr)
    {
        LOG_ERROR("init_from_file create_dummy_market error : %s", config_path.c_str());
        return false;
    }

    // 查找并处理 [dummy_trader] 部分
    it = ini.sections.find("dummy_trader");
    if (it == ini.sections.end())
    {
        LOG_ERROR("init_from_file cant find [dummy_trader]", config_path.c_str());
        return false;
    }
    _trader_simulator = create_dummy_trader(it->second); // 创建交易模拟器
    if (_trader_simulator == nullptr)
    {
        LOG_ERROR("init_from_file create_dummy_trader error : %s", config_path.c_str());
        return false;
    }
    
    // 查找并处理 [recorder] 部分
    it = ini.sections.find("recorder");
    if (it != ini.sections.end())
    {
        params recorder_patams(it->second); // 解析 recorder 部分的参数
        const auto& recorder_path = recorder_patams.get<std::string>("basic_path");
        _recorder = std::make_shared<csv_recorder>(recorder_path.c_str()); // 创建 CSV 记录器
    }
    
    // 查找并处理 [control] 部分
    it = ini.sections.find("control");
    if (it == ini.sections.end())
    {
        LOG_ERROR("init_from_file cant find [control]", config_path.c_str());
        return false;
    }
    params control_patams(it->second); // 解析 control 部分的参数
    this->init(control_patams, include_patams, true); // 初始化 evaluate 对象
    return true;
}

// 播放历史数据
void evaluate::playback_history() noexcept
{
    if (_market_simulator)
    {   
        // 播放市场数据
        _market_simulator->play(_trader_simulator->get_trading_day(), [this](const tick_info& tick) -> void {
            _trader_simulator->push_tick(tick); // 将 tick 数据推送到交易模拟器
        });

        // 等待市场模拟器完成数据播放
        while (!_market_simulator->is_finished())
        {
            std::this_thread::sleep_for(std::chrono::seconds(1)); // 每秒检查一次
        }

        // 记录结算数据
        if (_recorder)
        {
            _recorder->record_crossday_flow(_trader_simulator->get_trading_day(), get_all_statistic(), _trader_simulator->get_account());
        }
    }
}

// 模拟跨日数据
void evaluate::simulate_crossday(uint32_t trading_day) noexcept
{
    if (_trader_simulator)
    {
        _trader_simulator->crossday(trading_day); // 执行跨日模拟
    }
}

// 获取交易模拟器
trader_api& evaluate::get_trader() noexcept
{
    return *_trader_simulator; // 返回交易模拟器的引用
}

// 获取市场模拟器
market_api& evaluate::get_market() noexcept
{
    return *_market_simulator; // 返回市场模拟器的引用
}

// 更新操作
void evaluate::on_update() noexcept
{
    // 当前没有实现，预留接口
}

// 判断是否终止
bool evaluate::is_terminaled() noexcept
{
    return true; // 永远返回 true，表示已经终止
}
